home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 18 / CU Amiga Magazine's Super CD-ROM 18 (1997)(EMAP Images)(GB)[!][issue 1998-01].iso / CUCD / Online / CNetDemo / cnet / sdk / include / cnetfuncs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-09-04  |  31.8 KB  |  786 lines
  1. #include <exec/types.h>
  2.  
  3. /* CNET.LIBRARY functions */
  4.  
  5. short  ReplaceText            ( char *line, char *from, char *with );
  6. long   GiveAmigaDays          ( struct IsDate *date );
  7. void   FormDate               ( struct IsDate *date, long *parts );
  8. void   AlterDate              ( struct IsDate *date, long i );
  9. void   UltimateFindParts      ( char *buffer, long min, long max, long *nparts, long *parts );
  10. void   ExpandFlags            ( long def, char *where );
  11. long   ConvertAccess          ( char *s );
  12. void   OneLessUser            ( struct SubboardType4 *s );
  13. UBYTE  OneMoreUser            ( struct SubboardType4 *s, UBYTE lock );
  14. long   SaveFree               ( struct SubboardType4 *s );
  15. long   FreeText               ( struct SubboardType4 *s, long pos, long length );
  16. long   AllocText              ( struct SubboardType4 *s, long length );
  17. struct UserData *LockAccount  ( short acc );
  18. void   UnLockAccount          ( short acc, UBYTE save );
  19. long   FindPhone              ( short *n, char *phone, short id );
  20. long   FindHandle             ( short *n, char *name,  short id );
  21. void   FormatVanilla          ( BPTR in, BPTR out );
  22. void   MakeDateZone           ( struct IsDate *date, char *whereto, char **text, BYTE tz, BYTE form  );
  23. void   ZPutItem               ( struct ItemType3 *Item0, struct ItemHeader *ihead0, struct SubboardType4 *s, short c );
  24. void   ZGetItem               ( struct ItemType3 *Item0, struct ItemHeader *ihead0, struct SubboardType4 *s, short c );
  25. UBYTE  ZAddItem               ( struct ItemType3 *Item0, struct ItemHeader *ihead0, struct SubboardType4 *s );
  26. void   ZAddMessage            ( struct MessageType3 *Message0, struct SubboardType4 *s );
  27. void   DelayAddItems          ( struct SubboardType4 *s );
  28. void   FlushAddItems          ( struct SubboardType4 *s );
  29. UBYTE  FileOLM                ( struct PortData *z, char *text, short id, long flags );
  30. UBYTE  XAddCharge             ( struct ChargeSet *set, short id, short n, short a, char *info );
  31. void   AddCredits             ( struct ItemType3 *i, short m );
  32. void   WriteLog               ( struct PortData *z, short n, char *text1, char *text2 );
  33. ULONG  DirectorySize          ( char *dir, BPTR lock );
  34. short  FileExists             ( char *filename);
  35. void   CreateMailDir          ( char *uucpid);
  36. UBYTE  CreateFolderName       ( char *destpath, char *UUCP, char *foldername);
  37. short  BuildDir               ( char *path );
  38. short  BitPosition            ( LONG bitpattern);                        // returns the actual position of the highest SET bit in bitpattern
  39. void   MCIFilter              ( char *text, LONG length, short flags);   // flags==1 -> filter CTRL-Y, flags==2 -> filter CTRL-Q, flags==3 -> filter both */
  40. LONG   AccountToID            ( LONG account);
  41. LONG   IDToAccount            ( LONG userid);
  42. void   StrToUpper             ( char *string);               // 25-Jan-97 -  Converts string to all uppercase
  43. LONG   FileSize               ( char *Name);                 // 25-Jan-97 - Get size of file (requires full path and filename)
  44. BYTE   AddIdentdUser          ( short Port, LONG Socket);    // CNetPort number and Socket as args, return 0 on success
  45. BYTE   RemoveIdentdUser       ( ULONG Socket);               // socket as arg, return 0 on success
  46. short  LookupIdentd           ( ULONG Socket);               // returns CNet PORT number (-1 if not found)
  47. UBYTE  CNetAddressType        ( char *user);                 // returns ADDRESSTYPE_* - see mail.h
  48. LONG   CNetAddressToAccount   ( char *a );                   // lookup account number by CNet UUCP/MailID
  49. char   *HNameToUUCP           ( char *hname );               // lookup UUCP/MailID by handle/real name
  50. char   *CNetIDToUUCP          ( LONG userid );               // lookup UUCP/MailID from user serial IDNumber
  51. short  NumFromUnique          ( char *gokeyword );           // returns physical subboard number for identical (case insensitive) match of gokeyword
  52. struct Node *FindOrdinal      ( struct List *list, short n); // accepts an Exec list pointer and a number (N) and returns the Nth node in the Exec list
  53. short  InStr                  ( char *string, char *isin );  // check to see if <isin> is a substring of <string>
  54. BOOL   AllDigits              ( char *string);               // is string all numeric characters?? returns TRUE if so.
  55. void   CopyFilterText         ( char *dest, char *source);   // copies source to destination, removing MCI
  56.                                                              // and CR/LF in the process - this is the function
  57.                                                              // used to prepare text to be displayed in CNet GUIs
  58. struct PortData *IsNowOnLine  (struct MainPort *myp, short acc );
  59. void   GetRFCDate             ( char *datedest);
  60. BOOL   AppendToFile           ( char *filename, char *text, BOOL AddCR); // add text to filename with or without CR (newline character)
  61. /* end of CNET.LIBRARY functions */
  62.  
  63.  
  64. /* pragmas for CNET.LIBRARY */
  65. #pragma libcall CNetBase ReplaceText 1e A9803
  66. #pragma libcall CNetBase GiveAmigaDays 24 801
  67. #pragma libcall CNetBase FormDate 2a 9802
  68. #pragma libcall CNetBase AlterDate 30 0802
  69. #pragma libcall CNetBase UltimateFindParts 36 A910805
  70. #pragma libcall CNetBase ExpandFlags 3c 8002
  71. #pragma libcall CNetBase ConvertAccess 42 801
  72. #pragma libcall CNetBase SaveFree 48 801
  73. #pragma libcall CNetBase OneLessUser 4e 801
  74. #pragma libcall CNetBase OneMoreUser 54 0802
  75. #pragma libcall CNetBase FreeText 5a 10803
  76. #pragma libcall CNetBase AllocText 60 0802
  77. #pragma libcall CNetBase LockAccount 66 001
  78. #pragma libcall CNetBase UnLockAccount 6c 1002
  79. #pragma libcall CNetBase FindPhone 72 09803
  80. #pragma libcall CNetBase FindHandle 78 09803
  81. #pragma libcall CNetBase FormatVanilla 7e 9802
  82. #pragma libcall CNetBase MakeDateZone 84 10A9805
  83. #pragma libcall CNetBase ZPutItem 8a 0A9804
  84. #pragma libcall CNetBase ZGetItem 90 0A9804
  85. #pragma libcall CNetBase ZAddItem 96 A9803
  86. #pragma libcall CNetBase ZAddMessage 9c 9802
  87. #pragma libcall CNetBase DelayAddItems a2 801
  88. #pragma libcall CNetBase FlushAddItems a8 801
  89. #pragma libcall CNetBase FileOLM ae 109804
  90. #pragma libcall CNetBase XAddCharge b4 9210805
  91. #pragma libcall CNetBase AddCredits ba 0802
  92. #pragma libcall CNetBase WriteLog c0 A90804
  93. #pragma libcall CNetBase DirectorySize c6 9802
  94. #pragma libcall CNetBase FileExists cc 801
  95. #pragma libcall CNetBase CreateMailDir d2 801
  96. #pragma libcall CNetBase CreateFolderName d8 A9803
  97. #pragma libcall CNetBase BuildDir de 801
  98. #pragma libcall CNetBase BitPosition e4 001
  99. #pragma libcall CNetBase MCIFilter ea 10803
  100. #pragma libcall CNetBase AccountToID f0 001
  101. #pragma libcall CNetBase IDToAccount f6 001
  102. #pragma libcall CNetBase StrToUpper fc 801
  103. #pragma libcall CNetBase FileSize 102 801
  104. #pragma libcall CNetBase AddIdentdUser 108 1002
  105. #pragma libcall CNetBase RemoveIdentdUser 10e 001
  106. #pragma libcall CNetBase LookupIdentd 114 001
  107. #pragma libcall CNetBase CNetAddressType 11a 801
  108. #pragma libcall CNetBase CNetAddressToAccount 120 801
  109. #pragma libcall CNetBase HNameToUUCP 126 801
  110. #pragma libcall CNetBase CNetIDToUUCP 12c 001
  111. #pragma libcall CNetBase NumFromUnique 132 801
  112. #pragma libcall CNetBase FindOrdinal 138 0802
  113. #pragma libcall CNetBase InStr 13e 9802
  114. #pragma libcall CNetBase AllDigits 144 801
  115. #pragma libcall CNetBase CopyFilterText 14a 9802
  116. #pragma libcall CNetBase IsNowOnLine 150 0802
  117. #pragma libcall CNetBase GetRFCDate 156 801
  118. #pragma libcall CNetBase AppendToFile 15c 09803
  119. /* end of pragmas for CNET.LIBRARY */
  120.  
  121.  
  122.  
  123. void YankQueue( void );
  124. short SkipDrop( short r, short d, short count );
  125. //char RexxSetRootName( char *s );
  126. char *RexxModem( char *s );
  127. void UploadQWK( void );
  128. UBYTE HasMaint( void );
  129. void ManageFile0( void );
  130. void UnManageFile0( void );
  131. void CopyCDROM( struct SelectType *select, UBYTE create );
  132. void RequestFiles( void );
  133. void ListMembers( void );
  134. void DirectFileLoop( void (*dfunct)( char *name ) );
  135. void PostNetwork( void );
  136. void SetHeaderDates( void );
  137. UBYTE CanPostUUCP( void );
  138. void FormatFidoEd( struct FidoNet *fidonet, struct FidoType *net, short sig, char *area );
  139. void FormatVanillaEd( char *group, char *subject, char *dist, char *organ );
  140. void ReadUUCP( void );
  141. short FindItem( long number );
  142. UBYTE TempMoveToSub( short sub, long item, UBYTE show );
  143. void ReturnToSub( short list0, short br0 );
  144. void VDEclose( void );
  145. void VDEapply( void *data0, void *data1 );
  146. void AutoJoinLink( char *dial );
  147. void JoinLink( void );
  148. void DropDTR( void );
  149. UBYTE SaveAccount( struct UserData *user, short id );
  150. UBYTE ReadAccountLock( short id, struct UserData *user );
  151. UBYTE ReadAccount( short id, struct UserData *user );
  152.  
  153. void Squery( struct RangeContext *rc, char *command );
  154. BPTR OpenAppend( char *name );
  155. UBYTE TimedWaitIO( struct IORequest *areq, ULONG wbit, ULONG secs );
  156. void LoadInfo( UBYTE close );
  157.  
  158. void YMarkRec( BPTR kp, long pos, struct HeaderType *head );
  159. void SetDownloadCredits( void );
  160. void AdoptQWK( void );
  161. short IsAMember( char *name );
  162. void GetBaseUser( short id, struct BaseUser *bp );
  163. void PutBaseUser( short id, struct BaseUser *bp );
  164.  
  165. BPTR OpenPost( BPTR was );
  166. void EditItems( void );
  167. UBYTE EditOne( long r );
  168. void QuickSearch( void );
  169. UBYTE DupCheck( char *name );
  170.  
  171. char *RexxGetUser( char *arg );
  172. char *RexxPutUser( char *arg );
  173.  
  174. UBYTE ReadHeader( BPTR fh, long pos, struct HeaderType *head );
  175. void BaseSaveEditor( BPTR fh, short num );
  176. long SizeOfMessage( short num );
  177. long SaveText( long prev, short sig );
  178. long SaveResponse( void );
  179. long SaveItem( short sig );
  180. long KillResponse( long pos );
  181. long NewText( long pos, short sig );
  182. long EditResponse( long pos );
  183.  
  184. void MarkReceived( char *path, long pos );
  185. long LocateResponse( BPTR fh, long resp );
  186. void GetAllItems( void );
  187. void AdoptLocalDefaults( void );
  188.  
  189. void ReadM0( void );
  190. void SetSubStuff( short base );
  191. void DisplaySubPath( void );
  192. void ShowGlobalPath( void );
  193.  
  194. void ReadMarked( void );
  195. void ExtSetMinFree( long free );
  196. UBYTE ExtSetProtocol( char a );
  197. char *ExtDownload( char *args );
  198. char *ExtUpload( char *args );
  199.  
  200. void FixCase( ULONG opts );
  201. void MakePath( char *where );
  202. void ChangeExchange( void );
  203. void SetCapture( void );
  204. void OpenCapture( char force );
  205. void WriteSubboard( void );
  206. short SetSigNumber( short num );
  207. void OpenYank( short parm );
  208. void ReadOne( void );
  209. void GetMessage( long b );
  210. void Rquery( char *command, UBYTE deftype );
  211. UBYTE GoItem( UBYTE nof, UBYTE file );
  212. UBYTE IsPrivate( void );
  213. UBYTE IsUnvalidated( void );
  214. UBYTE ReadJoined( struct BaseUser **p, short r );
  215. UBYTE ChangeDate( struct IsDate *date );
  216. void ChangeNew( void );
  217. UBYTE Rsetup( UBYTE deftype, UBYTE chrono );
  218. UBYTE Rnext( void );
  219. void SToUpper( char *s );
  220. void AMLogWrite( char *line );
  221. void ArrangeItemPointers( void );
  222. UBYTE SearchOne( void );
  223.  
  224. void MultiMail( void );
  225. void ExitSubboard( UBYTE quiet );
  226.  
  227. void SendToMailBox( void );
  228. void ScanForNewFiles( void );
  229. void ScanForNewMessages( void );
  230. void NewScanAtLogon( void );
  231. short VisualDataEditor( char *file, void *data, long size );
  232.  
  233. void ShowMailHeader( struct MailHeader *m, short number, short of, short samv );
  234. UBYTE SelectAndDownload( char *file, UBYTE flags );
  235.  
  236. void LoadSelectList( void );
  237. void SaveSelectList( void );
  238. void SaveSelectListLock( void );
  239.  
  240. void LoadBaseUser( void );
  241. void SaveBaseUser( void );
  242.  
  243. void LogOffUser( void );
  244. void TermLink( void );
  245. void DoPortMonitor( void );
  246. void DoTermLink( void );
  247. void DoRange( struct RangeContext *rc, long min, long max, long defmin, long defmax );
  248. long GetNext( struct RangeContext *rc );
  249.  
  250. void SetByAndTo( void );
  251. UBYTE existf( char *name );
  252. void AdoptItemStuff( void );
  253. UBYTE SetItemStuff( UBYTE qwk );
  254. void TestOne( void );
  255. void TestItems( void );
  256. void TransformOne( void );
  257. void TransformItems( void );
  258.  
  259. void AskAPlan( UBYTE time, UBYTE sysop, char *maildir );
  260. void SafeFreeMem( void *b, ULONG s );
  261. void dispRexxPort( void );
  262. void NormalizeScreen( void );
  263. void CallXPR( void );
  264. UBYTE ChangeDir( char *name );
  265. void BrowseItems( void );
  266. void EraseChat( void );
  267. UBYTE *FilePart( UBYTE *a );
  268. void GetSkyBrush( BPTR fd );
  269. void LoadBBSCharges( void );
  270. short LoadBBSText( char *loc, char **bm, char *name, long size );
  271. void LoadXLation( short t );
  272. void NormalizeColors( void );
  273. void ResetSRead( UBYTE on );
  274. void Rreset( void );
  275. UBYTE RunParagon( char *name );
  276. UBYTE RunC( char *name, char *args );
  277. UBYTE RunCPfile( char *name );
  278. UBYTE RunRexx( char *name );
  279. void sendcanx( void );
  280. void SetCreditStuff( void );
  281. void SetSelect( UBYTE *a );
  282. void SetUtilityClock( long mics );
  283. void ShowAccess( void );
  284. void ShowTimeLeft( void );
  285. char WaitForInput( long mics );
  286. UBYTE YesNo( UBYTE def );
  287. char CheckOLM( void );
  288.  
  289. void PutError( char *what );
  290. void GotoResponse( long n, BPTR fh );
  291. short FindArc( char *name );
  292. UBYTE CheckSysPassword( short x, char *banner );
  293. void SilentUpload( char p );
  294. void SilentDownload( char p );
  295. UBYTE Unknown( void );
  296. UBYTE CheckBBSTimes( void );
  297. UBYTE ReadGraphics( char *f, char fnf );
  298. void VerifyOff( void );
  299. void WaitScreen( void );
  300. void ModemCommand( char *s );
  301. UBYTE WaitForCall( void );
  302. void LogonScreen( void );
  303. void ResetLine( void );
  304. void ClearLine( void );
  305. void UserStatus( struct UserData *user, short ii );
  306. short FindAccount( char *text, struct UserData *user, UBYTE quiet );
  307. void UpdatePrivs( struct UserData *u );
  308. void UpdateAccess( BYTE access );
  309. void CheckChanges( void );
  310. long CommonCommands( void );
  311. UBYTE ReadLog( char *f );
  312. short SendMail( UBYTE edin );
  313. short FollowForward( short id, struct UserData *u );
  314. UBYTE CheckUrgentMail( void );
  315. short CountMail( short id );
  316. void CheckMail( char *mailid, char *foldername );
  317. void ReadMail( short id );
  318. void CopyMessage( BPTR fh, BPTR kh );
  319. void TimeDate( void );
  320. void Feedback( void );
  321. UBYTE LoginUser( void );
  322. void SetColors( short off );
  323. short CalculateAge( struct UserData *user );
  324. void OpenChat( void );
  325. void CloseChat( void );
  326. void CloseDisplay( void );
  327. UBYTE OpenDisplay( void );
  328. void WriteSAMSummary( void );
  329. void BadLogonReason( char *s );
  330. void ParseCommandLine( UBYTE numargs );
  331. short FindCommand( short menu );
  332.  
  333. UBYTE GetFilename( char *action );
  334. void ReadDirectory( short parent );
  335. void EntryPath( UBYTE exit );
  336. void EditEntryFile( UBYTE exit );
  337. void EntryFile( UBYTE exit );
  338. void ListSubboards( void );
  339. long ListSelected( UBYTE optdel );
  340. short FindSelect( char *name );
  341. short FindUpload( char *name );
  342. void NothingSelected( void );
  343. void NotValidated( void );
  344. void Base( UBYTE base );
  345. UBYTE OtherStuff( short r, UBYTE quiet, UBYTE enter );
  346. void MoveToList( short r );
  347. void MoveToArea( short r, UBYTE quiet );
  348. void SetNewMessages( UBYTE quiet );
  349. void SetThePrompt( void );
  350. UBYTE NewItem( struct IsDate *date, struct IsDate *base );
  351. int GetItemNumber( void );
  352. void PostMessage( UBYTE qwk );
  353. UBYTE OKFilename( char *name );
  354. void UploadFiles( void );
  355. UBYTE FileItem( void );
  356. void NextItem( void );
  357. void LastPost( void );
  358. void NoNumber( void );
  359. void OutScan( void );
  360. void ScanItems( void );
  361. char DoAnonymous( UBYTE to );
  362. void AboutPost( UBYTE new );
  363. UBYTE ValidateOne( UBYTE ud );
  364. void ValidateItems( void );
  365. void PutItem( short b );
  366. void GetItem( short b );
  367. void PrintOption( char *s, UBYTE *o );
  368. void KillItems( void );
  369. void RemovePost( UBYTE killit );
  370. void SaveHeaders( void );
  371. void GrabItems( void );
  372. UBYTE GrabOne( void );
  373. void GrabFile( char *name );
  374. void DownloadFiles( void );
  375. void PostHeader( void );
  376. void MessageHeader( void );
  377. void ReadItems( void );
  378. void AskDescription( void );
  379. void AddDescription( void );
  380. UBYTE PromptFileNote( char *filename );
  381. void AddFileNote( char *file );
  382. void LimitEditor( char *loc );
  383. UBYTE SetFrom( void );
  384. UBYTE SetMessageStuff( UBYTE qwk );
  385. void RespondOne( UBYTE qwk );
  386. void RespondItems( void );
  387. int ScanAll( void );
  388. int ScanNew( UBYTE quiet );
  389. int BetweenNew( void );
  390. void ViewSubOps( void );
  391. void DescribeOne( void );
  392. void DescribeItems( void );
  393. void SelectOne( UBYTE remove );
  394. void SelectItems( UBYTE remove );
  395. void SelectFile( UBYTE counttime, UBYTE remove );
  396. void RemoveSelect( short i );
  397. void RemoveUpload( short i );
  398. void ExtractOne( void );
  399. void ExtractItems( void );
  400. void ExtractFile( char *name );
  401. void SToLower( char *s );
  402. void CheckString( char *string );
  403. void SearchHere( void );
  404. UBYTE SearchText( UBYTE filters );
  405. void SearchEnd( void );
  406. void TraverseAll( int (*Func1)( void ), int(*Func2)( void ) );
  407. int TimeEstimate( int bytes );
  408. void AdoptOrphans( void );
  409. void DescribeBatch( char *shortfile );
  410. UBYTE CheckPrivacy( struct HeaderType *h, UBYTE quiet );
  411. UBYTE PrivateItem( void );
  412. UBYTE VerifyKill( void );
  413. void MakeLoc( short p );
  414. void FindLoc( void );
  415. long FindLargest( UBYTE quiet );
  416.  
  417. short GetWhichPort( UBYTE MustBeOn);
  418. void SendOLM( void );
  419. void ReadOLM( void );
  420. long ConferenceWait( short r );
  421. int EnterText( char firstkey, short max, short perline, short maxlines );
  422. void WhosHere( void );
  423. void HideOpts( char **text, UBYTE *all, UBYTE value );
  424. void CheckTellMe( char *s );
  425. void InterUserChat( short port );
  426. void ChatRequest( void );
  427. UBYTE CheckIUC( USHORT opts );
  428.  
  429. UBYTE RunDOS( char *name, char *arguments );
  430. void AddToBuffer( char c );
  431. long FileSize( char *path );
  432. long GrabFileSize( UBYTE quiet );
  433. long ListDir( UBYTE add, UBYTE counttime, struct IsDate *date );
  434. UBYTE OkName( char *n );
  435. void GetInfo( char *name, char *output );
  436. long GetFree( char *where, UBYTE quiet );
  437. void FindUnits( ULONG size, char *unit, ULONG chunk );
  438.  
  439. void EditorPrint( char *text );
  440.  
  441. void MakeEd( char *path );
  442. void DeleteEd( void );
  443. BPTR OpenEd( long mode );
  444. void PrepEditor( BPTR fh );
  445. void CallEditor( short max, short inlines );
  446. void SaveEditor( BPTR fh, UBYTE eof );
  447. char LineEditor( short max, UBYTE flags );
  448. char ExitSaveEditor( void );
  449. void DoMCIRead( void );
  450. void DoZip( void );
  451. UBYTE CJustify( char *prompt, void (*fn)() );
  452. void PutString( short line, short ww );
  453. void InsPoint( short line );
  454. void InsChar( short line, short col, short n );
  455. void DelChar( short line, short col, short n );
  456. void DelPoint( short line );
  457. void FunctLoop( void (*funct)(), short returns );
  458. UBYTE EdFindParts( UBYTE d );
  459. void FList( long line );
  460. void FnRead( long line );
  461. void FEdit( long line );
  462. void FReplace( long line );
  463. void FToggle( long line );
  464. void CDelete( void );
  465. void CBorder( void );
  466. void FCopy( long line );
  467. void CCopy( short *line );
  468. void FLeft( long line );
  469. void FRight( long line );
  470. void FCenter( long line );
  471. void FPacked( long line );
  472. void FIndent( long line );
  473. void FUnindent( long line );
  474. void FExpand( long line );
  475. void FFind( long line );
  476. void CGet( void );
  477. void CPut( void );
  478. void MakePrompt( char *s );
  479.  
  480. void PrintAGraph( void );
  481. void AddSAM( short a, long b );
  482. void DelSAM( short a, long b );
  483. void DisplaySAM( void );
  484. void SaveSAM( void );
  485. void EditAccount( void );
  486. UBYTE KillAccount( struct UserData *u, short ii );
  487. int EditHelp( UBYTE x );
  488. void EditGroup( void );
  489. void EditPrivs( struct Privs *p );
  490. void EditPrivFlags( struct Privs *p );
  491. void AccountSummary( UBYTE detail );
  492. void PrintSigned( int n, char *s );
  493. UBYTE CheckBalance( short n, short a );
  494. UBYTE AddCharge( short n, short a );
  495. void MyCredits( struct UserData *u );
  496.  
  497. short compstra( char *s, char *t );
  498. void ResetServ( UBYTE reset, UBYTE time );
  499. void AddKeyBuffer( char *c );
  500. void ConGetChar( void );
  501. void SerGetChar( void );
  502. void ClearBuffer( void );
  503. long GetABunch( char *buffer, long number );
  504. void PutChar( char s );
  505. char GetChar( ULONG mask );
  506. void PrintAnything( char *s );
  507. void DoPause( void );
  508. void PrintSlow( char *wherefrom, short howmany );
  509. void WaitModem( void );
  510. void CursorOff( void );
  511. void CursorOn( void );
  512. void PrintWorkbench( char *where, short howmany );
  513. void PrintPrinter( char *wherefrom, short howmany );
  514. void PrintConsole( char *where, short howmany );
  515. void PrintModem( char *where, short howmany );
  516. char OneKey( void );
  517. void ScreenBS( void );
  518. void DoBackspace( short count );
  519. void ScrollUp( void );
  520. void DoReturn( void );
  521. UBYTE ShowAbortKey( void );
  522. void CheckFlowControl( void );
  523. void PutText( char *wherefrom );
  524. UBYTE PutQ( char *a );
  525. void PutA( void );
  526. void SetBaudRate( ULONG baud );
  527. void Service( void );
  528. void CheckCarrier( void );
  529. void EnterPassword( UBYTE maxlen );
  530. UBYTE DoANSIBox( UBYTE maxlen, USHORT opts, char *prompt, short len );
  531. int EnterLine( UBYTE maxlen, ULONG opts, char *prompt );
  532. UBYTE CheckInputChar( UBYTE gfx );
  533. UBYTE ReadFile( char *filename, UBYTE fnf );
  534. void ReadText( BPTR fh, char *buffer, char *key );
  535. void ReadMessage( BPTR fh, char *key );
  536. void ReadMessagePoint( char *name, long pos );
  537. UBYTE LoadLine( BPTR fh, char *line, short w, short flags );
  538. void EditMessage( char *file );
  539. void EditMessageLines( short max, char *file );
  540. void MakeDate( struct IsDate *date, char *whereto );
  541. void GetDate( void );
  542. void ResetTime( void );
  543. void StatPrint( char *text, int XOffset, int YOffset, UBYTE colors );
  544. void DisplayStatScreen( void );
  545. void ShowCredits( void );
  546. void LoAccess( void );
  547. UBYTE NoMessages( void );
  548. long EnterAccess( char *prompt, long def );
  549. char *PrintAccess( int a, short n );
  550. short DeadKeyConvert( struct IntuiMessage *msg );
  551. void Print40( void );
  552. void ResetEnviron( void );
  553. void ResetFont( void );
  554. void AttemptOpenDisplay( void );
  555.  
  556. void ListItems( void );
  557. void AddItem( void );
  558. void SaveItemList( void );
  559. void KillItem( short i, UBYTE quiet );
  560. void EditItem( short i );
  561. UBYTE MakeChanges( struct ListItem *f );
  562. void CheckNews( void );
  563. UBYTE ObtainPfile( char *name, UBYTE restrict );
  564. void ReleasePfile( void );
  565. void AlphabetizeItems( void );
  566.  
  567. void DoMCI( char *string );
  568. void PutNumber( ULONG n );
  569. void SOHelp( short n );
  570. void DoStillOn( void );
  571. void DoCCG( UBYTE c );
  572. void DoANSI( UBYTE n, USHORT a, USHORT b );
  573. void DoANSIOut( UBYTE n );
  574. void EraseLineEnd( void );
  575. void EraseLineBegin( void );
  576. void AScrollUp( short line, short num );
  577. void AScrollDown( short line, short num );
  578. void DoSky( short which );
  579. void FreeSkyBrush( void );
  580.  
  581. void SaveAlpha( void );
  582. void SaveNos( void );
  583. UBYTE DoGeneral( short n );
  584. UBYTE EditProfile( void );
  585. UBYTE DoParams( void );
  586. UBYTE EditParams( void );
  587. void NewUser( void );
  588. UBYTE CheckBadFiles( char *f, char *s, char *d );
  589. short CheckHandle( void );
  590. void EditGeneral( short i );
  591. UBYTE EditPrefs( void );
  592. UBYTE DisplayList( char **text, short n, char *prompt, short def );
  593. void ListComp( void );
  594. void AutoCBV( short force );
  595.  
  596. void ToggleBott( char mode );
  597. void ToggleStat( char mode );
  598. void DoWEdit( UBYTE c );
  599. void SetDoing( char *what );
  600. void InitMenu( void ); // portcheck: 100=default (no port selected) otherwise port that is highlighted in Control panel
  601. void ControlCommand( short c );
  602.  
  603. void Terminal( void );
  604. void DoTermMenu( long code );
  605. void AdjustPath( void );
  606.  
  607. void CarriageReturn( void );
  608. void ClearStr( void );
  609. short Findend( void );
  610. void PutStr1( void );
  611. void GetStr( void );
  612. void Position( void );
  613. void Position2( void );
  614. void OutLine( short col );
  615. void ClearToEnd( void );
  616. char DoVisual( void );
  617. char DrawEditor( void );
  618. void DoInsLine( void );
  619. void DoEOP( void );
  620. void VInsChar( short n );
  621. void SetOut( void );
  622. void GoCorner( void );
  623. void GoHome( UBYTE title );
  624. void SendHome( void );
  625. void GoLeft( void );
  626. void GoRight( void );
  627. void GoUp( void );
  628. void SinsMany( short a );
  629. void SdelMany( short a );
  630. void GoDown( void );
  631. void DoLeft( void );
  632. void DoRight( void );
  633. UBYTE DoBS( void );
  634. void DoCR( void );
  635. void VDelChar( short x );
  636. UBYTE DoDelete( void );
  637. void DoTab( void );
  638. void DoILine( void );
  639. void DoDLine( void );
  640. void Pullups( void );
  641. void RemoveMCI( char *b );
  642.  
  643. void zprprotocol( char *a );
  644. void printsize( ULONG size );
  645. void zprbytes( long val );
  646. void zprblocks( USHORT b );
  647. void zprblocksize( USHORT b );
  648. void printerrors( long e );
  649. void plotstatus( char *message );
  650. void ploterrors( char *message );
  651. void plotblockcheck( char *message );
  652. void zprname( char *a );
  653. void endxfer( void );
  654. void AddDownload( void );
  655. void DLoadSelect( UBYTE optdel );
  656. void ULoadSelect( void );
  657. void XAddFile( void );
  658. UBYTE CheckTime( void );
  659. UBYTE DCheckOK( struct SelectType *sp, short number );
  660. UBYTE UCheckOK( UBYTE mode );
  661. UBYTE OKProtocol( void );
  662. UBYTE ChooseProtocol( struct UserData *u );
  663. UBYTE MatchProtocol( UBYTE what );
  664. UBYTE XOptions( char p );
  665. void LogTransfer( char type, UBYTE log );
  666. void AddTimeBenefit( void );
  667. void CheckVerification( void );
  668. void CloseTransfer( void );
  669. UBYTE OpenTransfer( void );
  670. void  CapsFirst( char *s );
  671. short instr( char *s, char *t );
  672.  
  673. /* ZenMetal v4.10 */
  674. APTR InitWinStruct( void );
  675. void CleanUpWindow( struct WinStruct *winstr);
  676. void DisplayGoKey( short base );
  677. void SetGoExt(short physnum);   // 28-Oct-96
  678. void MailDirRename(char *olduucp, char *newuucp);
  679. void SuggestUUCPName( char *uucpout, char *realname, short id);
  680. BOOL DupeUUCPName( char *uucpname, short id );
  681.  
  682. /* ZenMetal v4.11 */
  683. UBYTE LostYanks(char *uucpid);   /* check for lost Yanks/QWK packets and auto-select them */
  684.  
  685. /* ZenMetal v4.12 17-May-96 */
  686. void                  GetUTP            (time_t *t, struct tm *utp);
  687. short                  GetChargeNum      (struct ChargeSet *chargeptr);
  688. char                  *IDToUUCP         (LONG userid);               /* convert user ID to UUCP name */
  689. short                  UUCPToAccount      (char *uucp);                /* convert UUCP name to account number */
  690. char                  *HNameToUUCP      (char *hname);               /* Accepts handle or real name and returns UUCP name belonging to the name given.  Note that HANDLES are searched first! */
  691. ULONG DisplayNetInfo(char *netaddress ); // added 9-Jun-96
  692.  
  693. // v4.12d 21-Jun-96
  694. void LogEvent( char *text, BYTE start );
  695.  
  696. // v4.13  1-Jul-96
  697. BOOL GetFileDiz(char *name);
  698.  
  699. // v4.21 16-Aug-96
  700. BOOL SaveFileDiz(char *DizText, char *DizLength);
  701.  
  702. // v4.13c 18-Jul-96
  703. LONG StripDIZ(char *diztext, LONG dizlength);
  704.  
  705. // v4.20a 11-Aug-96
  706. UBYTE ManageOne( UBYTE DoTest, UBYTE DoTxform );
  707.  
  708. // v4.24d 08-Nov-96
  709. UBYTE TextReload( void ); // returns TRUE if reloaded, FALSE if BBS cannot lock
  710.                           // the reload_text variable.
  711.  
  712. // v4.24fr2 18-Jan-97
  713. BYTE WriteUKeys( BYTE getsem );   // write the bbs.keys file
  714.                                  // if getsem is TRUE, ObtainSemaphore is done on myp->SEM[1]
  715.                                  // you should NOT use getsem if you have already gotten a semaphore lock on myp->SEM[1]!
  716.                                  // See empty.c for a description of this function's purpose.
  717.  
  718. // Mail/Folder functions
  719. struct MailToList      *IsFido            (char *net,   USHORT *faddr,   struct CNetNodeDesc *nd, struct MailToList *mailtolist );  /* get node information for net address */
  720. struct MailToList      *IsLocal            (char *name, struct MailToList *mailtolist);
  721. struct MailToList      *IsUUCP            (char *net, struct MailToList *mailtolist );
  722. struct MailToList      *NameToList         (char *name, char *uucp, struct MailToList *mailtolist, UBYTE mailtype );
  723. void                  DisposeMailTo      (struct MailToList *mailtolist); /* free the list of mailto's */
  724. short                  GetMailHeaders      (short portnum, struct NewMailFolder *currentfolder); /* get mailheaders for folder "currentfolder" */
  725. struct MailHeader4   *GetMailHeader      (short num);                 /* get a pointer to mail number "num" in the header list attached to the current port */
  726. UBYTE                  UpdateMailHeader   (struct MailHeader4 *mhead); /* returns TRUE if success */
  727. void                  DisposeMailHeaders(short portnum);             /* free all mail headers attached to current port */
  728. char                  *GetMailText      (struct MailHeader4 *mhead, struct NewMailFolder *folder ); /* get message text belonging to mail header */
  729. char                  *DisposeMailText   (char *text);                /* free memory used for mail text */
  730. UBYTE                  CreateMailFolder   (char *foldername, char *UUCPName);
  731. void                  MailSendQuick      (LONG fromid, LONG toid, char *subject, char *text); /* send a quick LOCAL mail with no prompting! */
  732. UBYTE                  FMailSend         (struct MailHeader4 *mhead, struct MailToList *mailto, char *text);
  733. UBYTE                  MailMoveToFolder   (struct MailHeader4 *mhead, char *ownerUUCP, struct NewMailFolder *sourcefolder, char *destfoldername);
  734. UBYTE                  RemoveMailHeader   (struct MailHeader4 *mhead);
  735. LONG                  InitializeMailFolders(char *path, char *UUCP); /* search user's FOLDERS directory for available folders */
  736. UBYTE                  FolderToList(struct NewMailFolder *addfolder); /* Attach a new folder name to the list of folders - this function does NOT create the folders but puts a "placeholder" for the folder name in the list */
  737. void                  DisposeMailFolders( void );                    /* free/deallocate memory used for the current port's linked folders list */
  738. short                  BuildDir( char *path );                        /* create full path specified.  Builds nested directories also */
  739. short                  ListMailFolders( UBYTE Quiet );                /* list folders currently attached to the current port's Folders structure - returns the number of folders in the list
  740.                                                                        If Quiet=TRUE, only returns a count of the current folders with no listing */
  741. struct NewMailFolder   *GotoMailFolder( char *uucpid, char *foldername ); /* Calls FindFolder() to see if there is a named folder belonging to the specified user. If no matching folders are found, a temporary folder structure is returned with it's "temporary" variable set to 1. */
  742. UBYTE                  OpenMailFolderRead(struct NewMailFolder *rfolder, UBYTE quiet); /* opens the "_text" and "_header" files for the specified folder structure in READ mode and returns with the filehandle fields of the
  743.                                                                            NewMailFolder structure set to the opened files or sets the filehanbdles to 0 if non-existant.
  744.                                                                            Other errors returned are -1 if the header file was opened succesfully but no matching text/body
  745.                                                                            file was found.  This routine also adds the full path/file names opened to the myp->Locks locked file list. */
  746. UBYTE                  OpenMailFolderWrite(struct NewMailFolder *rfolder); /* opens the "_text" and "_header" files for the specified folder structure in READ mode and returns with the filehandle fields of the
  747.                                                                             NewMailFolder structure set to the opened files or sets the filehanbdles to 0 if non-existant.
  748.                                                                             Other errors returned are -1 if the header file was opened succesfully but no matching text/body file was found.  This routine also adds the
  749.                                                                             full path/file names opened to the myp->Locks locked file list. */
  750. struct NewMailFolder   *FindFolder(char *uucpid, char *foldername, struct NewMailFolder *FolderList);
  751.                           /* finds a folder belonging to the specified uucp id
  752.                              with the folder name specified, in the list
  753.                              passed as FolderList. */
  754. struct NewMailFolder *FolderFromNum(short num);
  755.                           /* finds folder number "num" in the list of folders */
  756.                           /* attached to the current port */
  757. void CloseMailFolder( struct NewMailFolder *afolder);
  758.                           /* close folder files (whether read or write)
  759.                              and deallocate any memory allocated for the
  760.                              folder if it is a "temporary" folder */
  761. UBYTE DestroyMailFolder(struct NewMailFolder *killfolder);
  762.                           /* removes the specified folder from   */
  763.                           /* the user's FOLDERS directory        */
  764. UBYTE RemoveFolderList(struct NewMailFolder *killfolder);
  765.                           /* removes the specified folder from */
  766.                           /* the list of folders attached to   */
  767.                           /* the current port                  */
  768.  
  769. UBYTE InfoFromShortFile(char *shortfile);   // added 12-Sept-1996
  770.  
  771. // 28-Jan-97 -> see empty.c for description
  772. BYTE InputSignalInit(char *portname);
  773. void InputSignalDispose( void );
  774.  
  775.  
  776. void SetTheDoing( struct SubboardType4 *sb);
  777. BOOL MoveFile(char *fromfile, char *tofile);
  778. short FindPhysNum(struct SubboardType4 *sp);
  779.  
  780. // 01-May-97
  781. UBYTE TrimShort(LONG maxlines, LONG linelen);
  782.  
  783. // 02-May-97
  784. void EditMailKill( void );            // global mailkill file editing - "MK" command
  785. void EditTwitFilters(UBYTE flags);   // personal mail filter file editing - MAIL;FILTER command
  786.